package com.warom.sdg.webview.jsinterface;

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.webkit.JavascriptInterface;

import com.google.gson.Gson;
import com.warom.sdg.dto.LoginDto;
import com.warom.sdg.dto.UserDto;
import com.warom.sdg.dto.UserIdDto;
import com.warom.sdg.dto.UserQueryDto;
import com.warom.sdg.model.ApiResponse;
import com.warom.sdg.model.UserEntity;
import com.warom.sdg.repository.UserRepository;
import com.warom.sdg.util.LogUtils;
import com.warom.sdg.util.UserPreferencesUtil;
import com.warom.sdg.webview.BaseWebViewJsInterface;
import com.warom.sdg.webview.WebViewWrapper;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Consumer;

/**
 * 用户管理WebView接口
 * 提供用户管理相关的JavaScript接口
 */
public class WebViewJsUserManagerInterface extends BaseWebViewJsInterface {
    private static final String TAG = "UserManagerJsInterface";

    private final Gson gson = new Gson();
    private final Handler mHandler = new Handler(Looper.getMainLooper());
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    private WebViewWrapper webViewWrapper;
    private UserRepository userRepository;
    private Context context;

    /**
     * 构造函数
     * @param context 上下文
     */
    public WebViewJsUserManagerInterface(Context context) {
        super(context, null);
        this.context = context;
        userRepository = new UserRepository(context);
    }

    /**
     * 构造函数
     * @param context 上下文
     * @param webViewWrapper WebView包装器
     */
    public WebViewJsUserManagerInterface(Context context, WebViewWrapper webViewWrapper) {
        super(context, webViewWrapper);
        this.context = context;
        this.webViewWrapper = webViewWrapper;
        userRepository = new UserRepository(context);
    }
    
    /**
     * 保存当前用户信息到SharedPreferences
     * @param user 用户实体
     */
    private void saveCurrentUserInfo(UserEntity user) {
        UserPreferencesUtil.saveCurrentUser(context, user);
    }
    
    /**
     * 从SharedPreferences获取当前用户信息
     * @param context 上下文
     * @return 当前用户实体，如果未登录则返回null
     */
    public static UserEntity getCurrentUser(Context context) {
        return UserPreferencesUtil.getCurrentUser(context);
    }
    
    /**
     * 从SharedPreferences获取当前用户名
     * @param context 上下文
     * @return 当前用户名，如果未登录则返回null
     */
    public static String getCurrentUsername(Context context) {
        return UserPreferencesUtil.getCurrentUsername(context);
    }
    
    /**
     * 从SharedPreferences获取当前用户角色
     * @param context 上下文
     * @return 当前用户角色，如果未登录则返回null
     */
    public static String getCurrentUserRole(Context context) {
        return UserPreferencesUtil.getCurrentUserRole(context);
    }
    
    /**
     * 清除当前用户信息（用于登出）
     * @param context 上下文
     */
    public static void clearCurrentUser(Context context) {
        UserPreferencesUtil.clearCurrentUser(context);
    }

    /**
     * 获取用户列表
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void getUserList(String requestId) {
        executor.execute(() -> getUserListAsync(null, requestId));
    }
    
    /**
     * 添加用户
     * @param args 参数（用户JSON）
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void addUser(String args, String requestId) {
        executor.execute(() -> addUserAsync(args, requestId));
    }
    
    /**
     * 更新用户
     * @param args 参数（用户JSON）
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void updateUser(String args, String requestId) {
        executor.execute(() -> updateUserAsync(args, requestId));
    }
    
    /**
     * 删除用户
     * @param args 参数（用户ID）
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void deleteUser(String args, String requestId) {
        executor.execute(() -> deleteUserAsync(args, requestId));
    }
    
    /**
     * 验证登录
     * @param args 参数（用户名和密码）
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void login(String args, String requestId) {
        executor.execute(() -> loginAsync(args, result -> handleAsyncResponse(requestId, result)));
    }
    
    /**
     * 登录验证 (异步版本，用于内部实现)
     * 
     * @param argsJson 参数，包含用户名和密码
     * @param callback 回调函数，接收登录结果的JSON字符串
     */
    private void loginAsync(String argsJson, Consumer<String> callback) {
        try {
            LogUtils.logOperation("用户管理", "登录", "开始验证用户登录");
            
            // 解析参数为LoginDto对象
            LoginDto loginDto = gson.fromJson(argsJson, LoginDto.class);
            
            // 验证参数
            if (loginDto == null || loginDto.getUsername() == null || loginDto.getPassword() == null || 
                loginDto.getUsername().isEmpty() || loginDto.getPassword().isEmpty()) {
                ApiResponse<String> response = ApiResponse.error("用户名和密码不能为空");
                callback.accept(response.toJson());
                return;
            }
            
            String username = loginDto.getUsername();
            String password = loginDto.getPassword();
            
            // 查询用户
            userRepository.getUserByUsername(username, user -> {
                if (user == null) {
                    ApiResponse<String> response = ApiResponse.error("用户不存在");
                    callback.accept(response.toJson());
                    return;
                }
                
                // 验证密码
                if (!user.getPassword().equals(password)) {
                    ApiResponse<String> response = ApiResponse.error("密码错误");
                    callback.accept(response.toJson());
                    return;
                }
                
                // 更新最后登录时间
                user.setLastLoginTime(System.currentTimeMillis());
                userRepository.update(user, () -> {
                    // 不返回密码
                    user.setPassword("******");
                    
                    // 记录登录日志
                    LogUtils.logOperation("用户管理", "登录成功", "用户: " + username);
                    
                    // 保存当前用户信息到SharedPreferences
                    saveCurrentUserInfo(user);
                    
                    // 直接使用ApiResponse包装用户对象
                    ApiResponse<UserEntity> response = ApiResponse.success("登录成功", user);
                    callback.accept(response.toJson());
                }, error -> {
                    // 更新失败，但登录仍然成功
                    user.setPassword("******");
                    
                    // 保存当前用户信息到SharedPreferences
                    saveCurrentUserInfo(user);
                    
                    ApiResponse<UserEntity> response = ApiResponse.success("登录成功，但更新登录时间失败", user);
                    callback.accept(response.toJson());
                });
            }, error -> {
                ApiResponse<String> response = ApiResponse.error("登录验证失败: " + error);
                callback.accept(response.toJson());
            });
        } catch (Exception e) {
            Log.e(TAG, "处理登录验证失败: " + e.getMessage(), e);
            ApiResponse<String> response = ApiResponse.error("登录验证失败: " + e.getMessage());
            callback.accept(response.toJson());
        }
    }
    
    /**
     * 异步获取用户列表
     * @param args 参数（可以为空或包含查询条件）
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void getUserListAsync(String args, String requestId) {
        executor.execute(() -> {
            try {
                // 解析查询参数（如果有）
                UserQueryDto queryDto = null;
                if (args != null && !args.isEmpty() && !args.equals("null")) {
                    queryDto = gson.fromJson(args, UserQueryDto.class);
                }
                
                // 获取用户列表
                userRepository.getAllUsers(users -> {
                    // 如果有查询条件，可以在这里进行过滤（目前简单实现，后续可扩展）
                    
                    // 处理密码，不返回明文密码
                    for (UserEntity user : users) {
                        user.setPassword("******");
                    }
                    
                    // 使用ApiResponse包装结果
                    ApiResponse<List<UserEntity>> response = ApiResponse.success("获取用户列表成功", users);
                    handleAsyncResponse(requestId, gson.toJson(response));
                }, error -> {
                    ApiResponse<List<UserEntity>> response = ApiResponse.error("获取用户列表失败: " + error);
                    handleAsyncResponse(requestId, gson.toJson(response));
                });
            } catch (Exception e) {
                Log.e(TAG, "获取用户列表失败: " + e.getMessage(), e);
                ApiResponse<List<UserEntity>> response = ApiResponse.error("获取用户列表失败: " + e.getMessage());
                handleAsyncResponse(requestId, gson.toJson(response));
            }
        });
    }
    
    /**
     * 异步添加用户
     * @param args 用户JSON字符串
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void addUserAsync(String args, String requestId) {
        executor.execute(() -> {
            try {
                LogUtils.logOperation("用户管理", "添加用户", "开始添加用户");
                
                // 解析用户数据为UserDto
                UserDto userDto = gson.fromJson(args, UserDto.class);
                
                // 验证参数
                if (userDto == null || userDto.getUsername() == null || userDto.getPassword() == null || 
                    userDto.getUsername().isEmpty() || userDto.getPassword().isEmpty()) {
                    ApiResponse<String> response = ApiResponse.error("用户名和密码不能为空");
                    handleAsyncResponse(requestId, gson.toJson(response));
                    return;
                }
                
                // 转换为实体对象
                UserEntity newUser = new UserEntity();
                newUser.setUsername(userDto.getUsername());
                newUser.setPassword(userDto.getPassword());
                newUser.setName(userDto.getName());
                newUser.setRole(userDto.getRole());
                newUser.setLastLoginTime(userDto.getLastLoginTime() > 0 ? 
                    userDto.getLastLoginTime() : System.currentTimeMillis());
                
                // 检查用户名是否已存在
                userRepository.getUserByUsername(newUser.getUsername(), existingUser -> {
                    if (existingUser != null) {
                        ApiResponse<String> response = ApiResponse.error("用户名已存在");
                        handleAsyncResponse(requestId, gson.toJson(response));
                    } else {
                        // 添加新用户
                        userRepository.insert(newUser, id -> {
                            // 设置新ID
                            newUser.setId(id);
                            
                            // 记录日志
                            LogUtils.logOperation("用户管理", "添加用户", "添加用户成功: " + newUser.getUsername());
                            
                            // 返回成功响应（不返回密码）
                            newUser.setPassword("******");
                            ApiResponse<UserEntity> response = ApiResponse.success("添加用户成功", newUser);
                            handleAsyncResponse(requestId, gson.toJson(response));
                        }, error -> {
                            ApiResponse<String> response = ApiResponse.error("添加用户失败: " + error);
                            handleAsyncResponse(requestId, gson.toJson(response));
                        });
                    }
                }, error -> {
                    ApiResponse<String> response = ApiResponse.error("检查用户名失败: " + error);
                    handleAsyncResponse(requestId, gson.toJson(response));
                });
            } catch (Exception e) {
                Log.e(TAG, "添加用户失败: " + e.getMessage(), e);
                ApiResponse<String> response = ApiResponse.error("添加用户失败: " + e.getMessage());
                handleAsyncResponse(requestId, gson.toJson(response));
            }
        });
    }
    
    /**
     * 异步更新用户
     * @param args 用户JSON字符串
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void updateUserAsync(String args, String requestId) {
        executor.execute(() -> {
            try {
                LogUtils.logOperation("用户管理", "更新用户", "开始更新用户");
                
                // 解析用户数据为UserDto
                UserDto userDto = gson.fromJson(args, UserDto.class);
                
                // 验证参数
                if (userDto == null || userDto.getId() == null || userDto.getId() <= 0) {
                    ApiResponse<String> response = ApiResponse.error("用户ID无效");
                    handleAsyncResponse(requestId, gson.toJson(response));
                    return;
                }
                
                // 转换为实体对象
                UserEntity updatedUser = new UserEntity();
                updatedUser.setId(userDto.getId());
                updatedUser.setUsername(userDto.getUsername());
                updatedUser.setPassword(userDto.getPassword());
                updatedUser.setName(userDto.getName());
                updatedUser.setRole(userDto.getRole());
                updatedUser.setLastLoginTime(userDto.getLastLoginTime());
                
                // 获取现有用户
                userRepository.getUserById(updatedUser.getId(), existingUser -> {
                    if (existingUser == null) {
                        ApiResponse<String> response = ApiResponse.error("用户不存在");
                        handleAsyncResponse(requestId, gson.toJson(response));
                    } else {
                        // 检查用户名是否已被其他用户使用
                        userRepository.getUserByUsername(updatedUser.getUsername(), userWithSameUsername -> {
                            if (userWithSameUsername != null && userWithSameUsername.getId() != updatedUser.getId()) {
                                ApiResponse<String> response = ApiResponse.error("用户名已被其他用户使用");
                                handleAsyncResponse(requestId, gson.toJson(response));
                            } else {
                                // 如果密码为空或为占位符，保留原密码
                                if (updatedUser.getPassword() == null || updatedUser.getPassword().isEmpty() || 
                                    updatedUser.getPassword().equals("******")) {
                                    updatedUser.setPassword(existingUser.getPassword());
                                }
                                
                                // 更新用户
                                userRepository.update(updatedUser, () -> {
                                    // 记录日志
                                    LogUtils.logOperation("用户管理", "更新用户", "更新用户成功: " + updatedUser.getUsername());
                                    
                                    // 返回成功响应
                                    updatedUser.setPassword("******"); // 不返回明文密码
                                    ApiResponse<UserEntity> response = ApiResponse.success("更新用户成功", updatedUser);
                                    handleAsyncResponse(requestId, gson.toJson(response));
                                }, error -> {
                                    ApiResponse<String> response = ApiResponse.error("更新用户失败: " + error);
                                    handleAsyncResponse(requestId, gson.toJson(response));
                                });
                            }
                        }, error -> {
                            ApiResponse<String> response = ApiResponse.error("检查用户名失败: " + error);
                            handleAsyncResponse(requestId, gson.toJson(response));
                        });
                    }
                }, error -> {
                    ApiResponse<String> response = ApiResponse.error("获取用户失败: " + error);
                    handleAsyncResponse(requestId, gson.toJson(response));
                });
            } catch (Exception e) {
                Log.e(TAG, "更新用户失败: " + e.getMessage(), e);
                ApiResponse<String> response = ApiResponse.error("更新用户失败: " + e.getMessage());
                handleAsyncResponse(requestId, gson.toJson(response));
            }
        });
    }
    
    /**
     * 异步删除用户
     * @param args 用户ID JSON字符串
     * @param requestId 请求ID
     */
    @JavascriptInterface
    public void deleteUserAsync(String args, String requestId) {
        executor.execute(() -> {
            try {
                LogUtils.logOperation("用户管理", "删除用户", "开始删除用户");
                
                // 解析用户ID
                UserIdDto userIdDto = gson.fromJson(args, UserIdDto.class);
                
                // 验证参数
                if (userIdDto == null || userIdDto.getId() == null || userIdDto.getId() <= 0) {
                    ApiResponse<String> response = ApiResponse.error("用户ID无效");
                    handleAsyncResponse(requestId, gson.toJson(response));
                    return;
                }
                
                long userId = userIdDto.getId();
                
                // 获取用户信息
                userRepository.getUserById(userId, userToDelete -> {
                    if (userToDelete == null) {
                        ApiResponse<String> response = ApiResponse.error("用户不存在");
                        handleAsyncResponse(requestId, gson.toJson(response));
                    } else {
                        // 检查是否为管理员账户
                        if ("admin".equals(userToDelete.getUsername())) {
                            ApiResponse<String> response = ApiResponse.error("不能删除管理员账户");
                            handleAsyncResponse(requestId, gson.toJson(response));
                        } else {
                            // 删除用户
                            userRepository.delete(userToDelete, () -> {
                                // 记录日志
                                LogUtils.logOperation("用户管理", "删除用户", "删除用户成功: " + userToDelete.getUsername());
                                
                                // 返回成功响应
                                ApiResponse<String> response = ApiResponse.success("删除用户成功", userToDelete.getUsername());
                                handleAsyncResponse(requestId, gson.toJson(response));
                            }, error -> {
                                ApiResponse<String> response = ApiResponse.error("删除用户失败: " + error);
                                handleAsyncResponse(requestId, gson.toJson(response));
                            });
                        }
                    }
                }, error -> {
                    ApiResponse<String> response = ApiResponse.error("获取用户失败: " + error);
                    handleAsyncResponse(requestId, gson.toJson(response));
                });
            } catch (Exception e) {
                Log.e(TAG, "删除用户失败: " + e.getMessage(), e);
                ApiResponse<String> response = ApiResponse.error("删除用户失败: " + e.getMessage());
                handleAsyncResponse(requestId, gson.toJson(response));
            }
        });
    }


} 